package o;

import androidx.annotation.NonNull;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.nio.ByteBuffer;
import o.sg.d;

public class uy<Data> implements vk<byte[], Data> {
    private final e<Data> ˏ;

    public interface e<Data> {
        Class<Data> ˏ();

        Data ॱ(byte[] bArr);
    }

    public static class a implements vr<byte[], ByteBuffer> {
        @NonNull
        public vk<byte[], ByteBuffer> ˏ(@NonNull vo voVar) {
            return new uy(new e<ByteBuffer>(this) {
                final /* synthetic */ a ˎ;

                {
                    this.ˎ = r1;
                }

                public /* synthetic */ Object ॱ(byte[] bArr) {
                    return ˋ(bArr);
                }

                public ByteBuffer ˋ(byte[] bArr) {
                    return ByteBuffer.wrap(bArr);
                }

                public Class<ByteBuffer> ˏ() {
                    return ByteBuffer.class;
                }
            });
        }

        public void ॱ() {
        }
    }

    static class b<Data> implements sg<Data> {
        private final e<Data> ˊ;
        private final byte[] ˏ;

        b(byte[] bArr, e<Data> eVar) {
            this.ˏ = bArr;
            this.ˊ = eVar;
        }

        public void ˏ(@NonNull rl rlVar, @NonNull d<? super Data> dVar) {
            dVar.ॱ(this.ˊ.ॱ(this.ˏ));
        }

        public void ˏ() {
        }

        public void ॱ() {
        }

        @NonNull
        public Class<Data> ˋ() {
            return this.ˊ.ˏ();
        }

        @NonNull
        public rz ˎ() {
            return rz.LOCAL;
        }
    }

    public static class c implements vr<byte[], InputStream> {
        @NonNull
        public vk<byte[], InputStream> ˏ(@NonNull vo voVar) {
            return new uy(new e<InputStream>(this) {
                final /* synthetic */ c ˎ;

                {
                    this.ˎ = r1;
                }

                public /* synthetic */ Object ॱ(byte[] bArr) {
                    return ˎ(bArr);
                }

                public InputStream ˎ(byte[] bArr) {
                    return new ByteArrayInputStream(bArr);
                }

                public Class<InputStream> ˏ() {
                    return InputStream.class;
                }
            });
        }

        public void ॱ() {
        }
    }

    public uy(e<Data> eVar) {
        this.ˏ = eVar;
    }

    public o.vk.c<Data> ˎ(@NonNull byte[] bArr, int i, int i2, @NonNull sc scVar) {
        return new o.vk.c(new aai(bArr), new b(bArr, this.ˏ));
    }

    public boolean ˋ(@NonNull byte[] bArr) {
        return true;
    }
}
